
import torch
import torchvision
import torchvision.transforms as transforms


if torch.cuda.is_available():
    device = torch.device("cuda:0")
elif torch.backends.mps.is_available():
    device = torch.device("mps")

print(device)

cuda:0


transform = transforms.Compose([transforms.ToTensor()])

batch_size = 32

trainset = torchvision.datasets.FashionMNIST(
    root="./data", train=True, download=True, transform=transform
)
trainloader = torch.utils.data.DataLoader(
    trainset, batch_size=batch_size, shuffle=True
)

testset = torchvision.datasets.FashionMNIST(
    root="./data", train=False, download=True, transform=transform
)
testloader = torch.utils.data.DataLoader(
    testset, batch_size=batch_size, shuffle=True
)

classes = (
    "top",
    "Trouser",
    "Pullover",
    "Dress",
    "Coat",
    "Sandal",
    "Shirt",
    "Sneaker",
    "Bag",
    "Ankle boot",
)

print(type(testset[0][0]))

<class 'torch.Tensor'>


import matplotlib.pyplot as plt
import numpy as np


def imshow(img):
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1, 2, 0)))
    plt.axis("off")
    plt.show()


dataiter = iter(trainloader)
images, labels = next(dataiter)

def grid_show(images, nrow=8):
    imshow(torchvision.utils.make_grid(images, nrow=nrow))


def print_grid(labels, nrow=8):
    rows = [labels[n : n + nrow] for n in range(0, len(labels), nrow)]
    for r in rows:
        print(" ".join(f"{classes[c]:10s}" for c in r))

grid_show(images)
print_grid(labels)

Coat       Shirt      top        Dress      Dress      Sandal     Pullover   Sneaker   
Bag        Ankle boot Trouser    Ankle boot Ankle boot Bag        Trouser    Bag       
top        top        top        Pullover   Sandal     Bag        Sandal     Ankle boot
Pullover   Pullover   Sneaker    Pullover   Sneaker    top        Dress      Sandal


import torch.nn as nn
import torch.nn.functional as F


class LeNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.layer1 = nn.Sequential(
            nn.Conv2d(1, 20, 5),
            nn.ReLU(),
            nn.AvgPool2d(2, 2)
        )
        self.layer2 = nn.Sequential(
            nn.Conv2d(20, 50, 5),
            nn.ReLU(),
            nn.AvgPool2d(2, 2)
        )
        self.fc1 = nn.Linear(50 * 4 * 4, 300)
        self.relu1 = nn.ReLU()
        self.fc2 = nn.Linear(300, 100)
        self.relu2 = nn.ReLU()
        self.fc3 = nn.Linear(100, len(classes))

    def forward(self, x):
        out = self.layer1(x)
        out = self.layer2(out)
        out = out.reshape(out.size(0), -1)
        out = self.fc1(out)
        out = self.relu1(out)
        out = self.fc2(out)
        out = self.relu2(out)
        out = self.fc3(out)
        return out


import torch.optim as optim

net = LeNet().to(device)

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)


net.train()

for epoch in range(5):
    loss_sum = 0

    for images, labels in trainloader:
        images = images.to(device)
        labels = labels.to(device)
        
        output_images = net(images)
        loss = criterion(output_images, labels)
        loss_sum += loss
        loss.backward()

        optimizer.step()
        optimizer.zero_grad()

    print(f"epoch {epoch} loss: {loss_sum:.4f}")

epoch 0 loss: 2411.3281
epoch 1 loss: 1309.2604
epoch 2 loss: 1135.7634
epoch 3 loss: 1023.3450
epoch 4 loss: 941.5866


dataiter = iter(testloader)
images, labels = next(dataiter)

grid_show(images)
print("Ground Truth")
print_grid(labels)

outputs = net(images.to(device))
_, predicted = torch.max(outputs, 1)

print()
print("Predicted")
print_grid(predicted)

Ground Truth
Sneaker    Shirt      Pullover   Bag        Dress      Sandal     Coat       Pullover  
Coat       Bag        Sandal     Ankle boot Bag        Shirt      Bag        Ankle boot
Shirt      top        Ankle boot Coat       Coat       Shirt      Dress      Bag       
Pullover   Sandal     Coat       Bag        Trouser    top        Sneaker    Sneaker   

Predicted
Sneaker    Shirt      Shirt      Bag        Pullover   Sandal     Coat       Shirt     
Shirt      Bag        Sandal     Ankle boot Bag        Shirt      Bag        Ankle boot
Coat       Dress      Ankle boot Coat       Coat       Shirt      Dress      Bag       
Pullover   Sandal     Coat       Bag        Trouser    top        Ankle boot Sneaker


correct = 0
total = 0
net.eval()
with torch.no_grad():
    for data in testloader:
        images, labels = data
        outputs = net(images.to(device))
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels.to(device)).sum().item()

print(f"Accuracy of the network on the 10000 test images: {100 * correct // total} %")

Accuracy of the network on the 10000 test images: 81 %


net.eval()

class_correct = [0] * len(classes)
class_total = [0] * len(classes)

with torch.no_grad():
    for data in testloader:
        images, labels = data
        outputs = net(images.to(device))
        _, predicted = torch.max(outputs.data, 1)
        
        for i in range(len(classes)):
            class_total[i] += (labels == i).sum().item()
            class_correct[i] += (predicted == labels.to(device))[labels == i].sum().item()

for i in range(len(classes)):
    print(f"Accuracy of {classes[i]}: {100 * class_correct[i] // class_total[i]}%")

Accuracy of top: 68%
Accuracy of Trouser: 93%
Accuracy of Pullover: 58%
Accuracy of Dress: 85%
Accuracy of Coat: 82%
Accuracy of Sandal: 94%
Accuracy of Shirt: 51%
Accuracy of Sneaker: 90%
Accuracy of Bag: 95%
Accuracy of Ankle boot: 93%


from torchvision.models import detection
import numpy as np
import cv2
from PIL import Image
import urllib


def url_to_image(url):
    resp = urllib.request.urlopen(url)
    image = np.asarray(bytearray(resp.read()), dtype="uint8")
    image = cv2.imdecode(image, cv2.IMREAD_COLOR)
    return image


classes = [
    "__background__",
    "person",
    "bicycle",
    "car",
    "motorcycle",
    "airplane",
    "bus",
    "train",
    "truck",
    "boat",
    "traffic light",
    "fire hydrant",
    "street sign",
    "stop sign",
    "parking meter",
    "bench",
    "bird",
    "cat",
    "dog",
    "horse",
    "sheep",
    "cow",
    "elephant",
    "bear",
    "zebra",
    "giraffe",
    "hat",
    "backpack",
    "umbrella",
    "handbag",
    "tie",
    "shoe",
    "eye glasses",
    "suitcase",
    "frisbee",
    "skis",
    "snowboard",
    "sports ball",
    "kite",
    "baseball bat",
    "baseball glove",
    "skateboard",
    "surfboard",
    "tennis racket",
    "bottle",
    "plate",
    "wine glass",
    "cup",
    "fork",
    "knife",
    "spoon",
    "bowl",
    "banana",
    "apple",
    "sandwich",
    "orange",
    "broccoli",
    "carrot",
    "hot dog",
    "pizza",
    "donut",
    "cake",
    "chair",
    "couch",
    "potted plant",
    "bed",
    "mirror",
    "dining table",
    "window",
    "desk",
    "toilet",
    "door",
    "tv",
    "laptop",
    "mouse",
    "remote",
    "keyboard",
    "cell phone",
    "microwave",
    "oven",
    "toaster",
    "sink",
    "refrigerator",
    "blender",
    "book",
    "clock",
    "vase",
    "scissors",
    "teddy bear",
    "hair drier",
    "toothbrush",
]

colors = np.random.randint(0, 256, size=(len(classes), 3))


model = detection.fasterrcnn_resnet50_fpn(
    weights=detection.FasterRCNN_ResNet50_FPN_Weights.DEFAULT,
    weights_backbone=torchvision.models.ResNet50_Weights.DEFAULT,
    progress=True,
    num_classes=len(classes)
).to(device)
model.eval()


# Pobieranie obrazka z sieci
!wget https://upload.wikimedia.org/wikipedia/commons/thumb/7/7a/Toothbrush_x3_20050716_001.jpg/1280px-Toothbrush_x3_20050716_001.jpg --output-document toothbrushes.jpg

'wget' is not recognized as an internal or external command,
operable program or batch file.


# Wyświetlanie obrazka
image = Image.open("toothbrushes.jpg")
# make sure we have 3-channel RGB, e.g. without transparency
image = image.convert("RGB")
display(image)


image_tensor = torch.from_numpy(np.array(image))
image_tensor = image_tensor.permute(2, 0, 1)
image_tensor_int = image_tensor  # useful for displaying, dtype = uint8
image_tensor = image_tensor / 255
image_tensor.shape, image_tensor.dtype

(torch.Size([3, 960, 1280]), torch.float32)


from copy import deepcopy
from PIL import ImageDraw

with torch.no_grad():
    output = model([image_tensor.to(device)])

boxes = output[0]['boxes'].cpu().numpy()
labels = output[0]['labels'].cpu().numpy()
scores = output[0]['scores'].cpu().numpy()

image_with_bb = deepcopy(image)
draw = ImageDraw.Draw(image_with_bb)
    
for box, label, score in zip(boxes, labels, scores):
    if score > 0.5:
        draw.rectangle(box, outline='red', width=3)
        draw.text((box[0]+5, box[1]+3), f'{classes[label]}: {score:.2f}', fill='red')

display(image_with_bb)


# Download the hotdog dataset
!wget http://d2l-data.s3-accelerate.amazonaws.com/hotdog.zip
!unzip -n hotdog.zip

'wget' is not recognized as an internal or external command,
operable program or batch file.
'unzip' is not recognized as an internal or external command,
operable program or batch file.


torch.manual_seed(17)

normalize = transforms.Normalize(
    mean=[0.485, 0.456, 0.406],
    std=[0.229, 0.224, 0.225]
)

train_augs = torchvision.transforms.Compose(
    [
        torchvision.transforms.RandomResizedCrop(224),
        torchvision.transforms.RandomHorizontalFlip(),
        torchvision.transforms.ToTensor(),
        normalize,
    ]
)

test_augs = torchvision.transforms.Compose(
    [
        torchvision.transforms.Resize(256),
        torchvision.transforms.CenterCrop(224),
        torchvision.transforms.ToTensor(),
        normalize,
    ]
)


pretrained_net = torchvision.models.resnet18(weights=torchvision.models.ResNet18_Weights.IMAGENET1K_V1)


pretrained_net.fc

Linear(in_features=512, out_features=1000, bias=True)


finetuned_net = pretrained_net

finetuned_net.fc = nn.Linear(finetuned_net.fc.in_features, 2)

nn.init.normal_(finetuned_net.fc.weight)
nn.init.zeros_(finetuned_net.fc.bias)

Parameter containing:
tensor([0., 0.], requires_grad=True)


import time
import copy


def train_model(
    model, dataloaders, criterion, optimizer, num_epochs=25
):
    since = time.time()

    val_acc_history = []

    best_model_wts = copy.deepcopy(model.state_dict())
    best_acc = 0.0

    for epoch in range(1, num_epochs + 1):
        print("Epoch {}/{}".format(epoch, num_epochs))
        print("-" * 10)

        # Each epoch has a training and validation phase
        for phase in ["train", "val"]:
            if phase == "train":
                model.train()  # Set model to training mode
            else:
                model.eval()  # Set model to evaluate mode

            running_loss = 0.0
            running_corrects = 0

            # Iterate over data.
            for inputs, labels in dataloaders[phase]:
                inputs = inputs.to(device)
                labels = labels.to(device)

                # zero the parameter gradients
                optimizer.zero_grad()

                # forward
                # track history if only in train
                with torch.set_grad_enabled(phase == "train"):
                    # Get model outputs and calculate loss
                    
                    outputs = model(inputs)
                    loss = criterion(outputs, labels)
                    _, preds = torch.max(outputs, 1)

                    # backward + optimize only if in training phase
                    if phase == "train":
                        loss.backward()
                        optimizer.step()

                # statistics
                running_loss += loss.item() * inputs.size(0)
                running_corrects += torch.sum(preds == labels.data)

            epoch_loss = running_loss / len(dataloaders[phase].dataset)
            epoch_acc = running_corrects.float() / len(dataloaders[phase].dataset)

            print("{} Loss: {:.4f} Acc: {:.4f}".format(phase, epoch_loss, epoch_acc))

            # deep copy the model
            if phase == "val" and epoch_acc > best_acc:
                best_acc = epoch_acc
                best_model_wts = copy.deepcopy(model.state_dict())
            if phase == "val":
                val_acc_history.append(epoch_acc)

        print()

    time_elapsed = time.time() - since
    print(
        "Training complete in {:.0f}m {:.0f}s".format(
            time_elapsed // 60, time_elapsed % 60
        )
    )
    print("Best val Acc: {:4f}".format(best_acc))

    # load best model weights
    model.load_state_dict(best_model_wts)
    return model, val_acc_history


import os

data_dir = "hotdog"
batch_size = 32

model_ft = finetuned_net.to(device)
train_iter = torch.utils.data.DataLoader(
    torchvision.datasets.ImageFolder(
        os.path.join(data_dir, "train"), transform=train_augs
    ),
    batch_size=batch_size,
    shuffle=True,
)
test_iter = torch.utils.data.DataLoader(
    torchvision.datasets.ImageFolder(
        os.path.join(data_dir, "test"), transform=test_augs
    ),
    shuffle=True,
    batch_size=batch_size,
)
loss = nn.CrossEntropyLoss(reduction="none")


def train_fine_tuning(net, learning_rate, num_epochs=15):

    params = net.named_parameters()
    params1 = []
    params2 = []
    for name, param in params:
        if name == "fc.weight" or name == "fc.bias":
            params1.append(param)
        else:
            params2.append(param)

    trainer = torch.optim.SGD(
        [
            {"params": params1, "lr": learning_rate},
            {"params": params2, "lr": learning_rate * 10}
        ]
    )
    
    dataloaders_dict = {"train": train_iter, "val": test_iter}
    criterion = nn.CrossEntropyLoss()
    model_ft, hist = train_model(
        net, dataloaders_dict, criterion, trainer, num_epochs=num_epochs
    )
    return model_ft, hist


model_ft, hist = train_fine_tuning(model_ft, learning_rate=5e-5)

Epoch 1/15
----------
train Loss: 4.3790 Acc: 0.8155
val Loss: 2.5708 Acc: 0.9050

Epoch 2/15
----------
train Loss: 1.8604 Acc: 0.9000
val Loss: 1.5483 Acc: 0.9000

Epoch 3/15
----------
train Loss: 1.6009 Acc: 0.8975
val Loss: 1.1124 Acc: 0.9225

Epoch 4/15
----------
train Loss: 0.9929 Acc: 0.9160
val Loss: 1.0544 Acc: 0.9275

Epoch 5/15
----------
train Loss: 0.9642 Acc: 0.9260
val Loss: 1.1793 Acc: 0.9062

Epoch 6/15
----------
train Loss: 0.9287 Acc: 0.9180
val Loss: 0.8719 Acc: 0.9187

Epoch 7/15
----------
train Loss: 0.8030 Acc: 0.9250
val Loss: 0.9771 Acc: 0.9150

Epoch 8/15
----------
train Loss: 0.6185 Acc: 0.9280
val Loss: 0.7574 Acc: 0.9325

Epoch 9/15
----------
train Loss: 0.7549 Acc: 0.9285
val Loss: 0.7846 Acc: 0.9250

Epoch 10/15
----------
train Loss: 0.5375 Acc: 0.9380
val Loss: 0.7058 Acc: 0.9312

Epoch 11/15
----------
train Loss: 0.5001 Acc: 0.9410
val Loss: 0.8170 Acc: 0.9287

Epoch 12/15
----------
train Loss: 0.4840 Acc: 0.9330
val Loss: 0.7826 Acc: 0.9237

Epoch 13/15
----------
train Loss: 0.5275 Acc: 0.9355
val Loss: 0.7989 Acc: 0.9137

Epoch 14/15
----------
train Loss: 0.4412 Acc: 0.9375
val Loss: 0.7506 Acc: 0.9200

Epoch 15/15
----------
train Loss: 0.4407 Acc: 0.9410
val Loss: 0.9537 Acc: 0.9212

Training complete in 2m 37s
Best val Acc: 0.932500


def imshow(img, title=None):
    img = img.permute(1, 2, 0).numpy()
    means = np.array([0.485, 0.456, 0.406])
    stds = np.array([0.229, 0.224, 0.225])
    img = stds * img + means
    img = np.clip(img, 0, 1)

    plt.imshow(img)
    if title is not None:
        plt.title(title)
    
    plt.pause(0.001)


import matplotlib.pyplot as plt
plt.ion()  


def visualize_model(model, num_images=6):
    class_names = ["hotdog", "other"]
    model.eval()
    images_so_far = 0
    fig = plt.figure()
    with torch.no_grad():
        for i, (inputs, labels) in enumerate(test_iter):
            inputs = inputs.to(device)
            labels = labels.to(device)

            outputs = model(inputs)
            _, preds = torch.max(outputs, 1)

            for j in range(inputs.size()[0]):
                images_so_far += 1
                ax = plt.subplot(num_images // 2, 2, images_so_far)
                ax.axis('off')
                ax.set_title(f'predicted: {class_names[preds[j]]}')

                imshow(inputs.data[j].cpu())

                if images_so_far == num_images:
                    return


visualize_model(model_ft)

Konwolucyjne sieci neuronowe¶

Problem klasyfikacji obrazów¶

Konwolucja¶

Stride¶

Padding¶

Pooling¶

Sposoby redukcji przeuczenia¶

Budowa sieci CNN do klasyfikacji obrazów¶

LeNet¶

Detekcja obiektów¶

Fine-tuning i pretrening¶

Zadanie dla chętnych (3 punkty)¶